Remotely Monitoring/Diagnosing Distributed Components Of A Supervisory Process Control And Manufacturing Information Application From A Central Location

ABSTRACT

A centralized diagnostics management tool is disclosed that facilitates centralized monitoring of distributed components of a supervisory process control and manufacturing information application. The centralized diagnostics management tool includes a diagnostics management console shell that is customized according to a set of software modules that interface to data sources to populate views supported by the console shell. The console shell includes a set of view templates including controls for manipulating graphically displayed representations of data rendered by the distributed components. The console shell also includes an interface for exchanging requests and data with an extensible set of software modules that provide data links to ones of the set of distributed components. The software modules also define the customizable portions of the view rendered by the console shell.

CROSS REFERENCE TO RELATED APPLICATIONS

This application claims priority of Resnick et al. U.S. provisionalapplication Ser. No. 60/300,363 filed on Jun. 22, 2001, entitled “AnObject-based Architecture for Executing Supervisory Process Control andManufacturing Applications,” Rowley et al. U.S. provisional applicationSer. No. 60/300,174 filed on Jun. 22, 2001, entitled “Method forInstalling Supervisory Process Control and Manufacturing InformationSystem Software From a Remote Location and Dynamic Re-Binding Handles,”and McIntyre et al. U.S. provisional application Ser. No. 60/300,321filed on Jun. 22, 2001, entitled “Centralized Diagnostics In aSupervisory Process Control and Manufacturing Information ApplicationEnvironment.” The contents of each above identified provisionalapplication are expressly incorporated herein by reference in theirentirety including the contents and teachings of any referencescontained therein.

FIELD OF THE INVENTION

The present invention generally relates to the field of computerizedprocess control networks. More particularly, the present inventionrelates to supervisory process control and manufacturing informationsystems. Such systems generally execute above a control layer in aprocess control network to provide guidance to lower level controlelements and/or field devices such as, by way of example, programmablelogic controllers.

BACKGROUND OF THE INVENTION

Significant advances in industrial process control technology havevastly improved all aspects of factory and plant operation. Before theintroduction of today's modern industrial process control systems,industrial processes were operated/controlled by humans and rudimentarymechanical controls. As a consequence, the complexity and degree ofcontrol over a process was limited by the speed with which one or morepeople could ascertain a present status of various process statevariables, compare the current status to a desired operating level,calculate a corrective action (if needed), and implement a change to acontrol point to affect a change to a state variable.

Improvements to process control technology have enabled vastly largerand more complex industrial processes to be controlled via programmedcontrol processors. Control processors execute control programs thatread process status variables, execute control algorithms based upon thestatus variable data and desired set point information to render outputvalues for the control points in industrial processes. Such controlprocessors and programs support a substantially self-running industrialprocess (once set points are established).

Notwithstanding the ability of industrial processes to operate under thecontrol of programmed process controllers at previously established setpoints without intervention, supervisory control and monitoring ofcontrol processors and their associated processes is desirable. Suchoversight is provided by both humans and higher-level control programsat an application/human interface layer of a multilevel process controlnetwork. Such oversight is generally desired to verify proper executionof the controlled process under the lower-level process controllers andto configure the set points of the controlled process.

One of many challenges facing the designers/managers of often highlycomplex, distributed process control systems is to properlyload/maintain required software onto each one of a plurality ofsupervisory-level computers executing a portion of a distributedapplication. A challenge faced by the managers of such systems is thepotentially significant distances between the various computer devices(e.g., personal computers) executing the various portions of thedistributed supervisory process control application. Another challengeto the software loading process is the sheer volume of executables thatare transferred to the distributed computer devices. Yet anothercomplication is the potential existence, in cases where a service packis to be deployed, of previously installed components on the targetpersonal computer systems.

Keeping track of the operation of individual distributed components onan application loaded upon computers located throughout an industrialplant is another challenge faced by system administrators. Known systemsprovide centralized alarm capabilities that are monitored in a centralcontrol room. However, even when alarm conditions are not met, anadministrator still has an interest in determining how installedapplication objects are performing on a distributed system, and to takeremedial action if needed.

SUMMARY OF THE INVENTION

In accordance with the invention, a centralized diagnostics managementtool facilitates centralized monitoring of distributed components of asupervisory process control and manufacturing information application.The centralized diagnostics management tool includes a diagnosticsmanagement console shell that is customized according to a set ofsoftware modules that interface to data sources to populate viewssupported by the console shell. The console shell includes a set of viewtemplates including controls for manipulating graphically displayedrepresentations of data rendered by the distributed components. Theconsole shell also includes an interface for exchanging requests anddata with an extensible set of software modules that provide data linksto ones of the set of distributed components. The personality of theinterface is driven by a set of software modules that submit requests tothe distributed components to access exposed attributes corresponding tothe operational statuses of the components. The software modules alsodefine the customizable portions of the view rendered by the consoleshell.

BRIEF DESCRIPTION OF THE DRAWINGS

The appended claims set forth the features of the present invention withparticularity. The invention, together with its objects and advantages,may be best understood from the following detailed description taken inconjunction with the accompanying drawings of which:

FIG. 1 is a schematic diagram of an exemplary supervisory processcontrol network including a multi-layered supervisory process controland manufacturing information application;

FIG. 2 depicts a multi-tiered object arrangement for an application;

FIG. 3 depicts a set of attributes associated with a common portion forthe objects comprising the application;

FIG. 4 depicts a set of attributes associated with a platform-specificportion of a platform object;

FIG. 5 depicts a set of attributes associated with an engine object;

FIG. 6 depicts a set of attributes associated with a scheduler object;

FIG. 7 depicts a set of attributes associated with an exemplaryapplication object;

FIG. 8 is a sequence diagram summarizing a set of steps performed tostart up a multi-layered application embodying the present invention;

FIG. 9 is a sequence diagram summarizing a set of steps for moving anobject to another engine in a network comprising multiple applicationengines;

FIG. 10 is a schematic diagram depicting controlled components of asimple plant process;

FIG. 11 is a schematic diagram depicting the simple plant processcomponents logically grouped into areas.

FIG. 12 is a hierarchical tree structure depicting the grouping of areasin the plant arrangement of FIG. 11;

FIG. 13 is a hierarchical tree structure representing the derivationrelationships of objects of a supervisory process control applicationassociated with the plant process depicted in FIG. 10;

FIG. 14 a is a schematic drawing of a mixer vessel portion of the plantprocess depicted in FIG. 10;

FIG. 14 b is a hierarchical model view depicting the containmentrelationship of a MixerVessel compound application object templatecorresponding to the mixer vessel depicted in FIG. 14;

FIG. 15 is a hierarchical tree structure representing a derivationstructure for portions of the application associated with the hardwareof a system (e.g., platforms, engines, and device integration objects);

FIG. 16 is a hierarchical tree structure presenting a model view ofapplication object arrangement including the areas with which theapplication objects are associated;

FIG. 17 is a hierarchical tree structure presenting a deployment view ofthe application to a set of computer devices represented by identifiedplatform objects at the top level of the hierarchy;

FIG. 18 is a flowchart summarizing the steps for deploying softwarecomponents to a computer device in a set of computer devices carryingout a distributed supervisory process control and manufacturinginformation application;

FIG. 19 is a flowchart summarizing the steps for registering aconnection to a target object attribute and then submitting commands tothe object attribute in accordance with an embodiment of the presentinvention; and

FIG. 20 is a sequence diagram depicting a set of steps associated withmaintaining a connection to a referenced target object attributenotwithstanding it re-deployment to a new physical location in a networkupon which a distributed application is deployed;

FIG. 21 is a block diagram depicting the primary components of anextensible centralized diagnostic utility for managing the distributedobjects of an application;

FIG. 22 is a screen shot of an exemplary user interface depictingplatforms and their status within a distributed application; and

FIG. 23 is a screen shot of an exemplary user interface depicting thefields of attributes for a selected object.

DETAILED DESCRIPTION OF AN ILLUSTRATIVE EMBODIMENT

In view of the shortcomings of known supervisory process controlapplications with regard to adapting to changed process control systemarchitectures, a supervisory process control and manufacturinginformation system application architecture is described that offersusers the freedom to re-architect (e.g., augment, reconfigure, etc.)such applications, with minimal impact on the existing, underlying,process control system engineering. In particular, the disclosed systemarchitecture, described by way of example herein, comprises multiplelayers wherein each underlying layer exhibits a hosting relationship toa next higher layer. It is noted however, that such hosting relationshipdoes not extend to communications, and thus communications to/from ahosted layer need not pass through its host. In accordance with thedisclosed layered application architecture, an application object ishosted by an engine. The engine is hosted by a platform that correspondsto, for example, a personal computer with infrastructure software. Theintermediate engine layer abstracts the application object from theplatform architecture. Thus, location within a physical systemcontaining the application object need not be addressed by theapplication object.

One aspect of the disclosed supervisory process control andmanufacturing information application is an object hierarchy that freeshigh level application objects of design constraints associated with thecomputing system hardware upon which the application objects reside. Inparticular, the objects associated with a supervisory process controlapplication environment are arranged on physical computing devices in ahierarchy comprising a plurality of layers. Application objects executeat an application layer. The application objects are hosted by an engineobject at a middle layer. The engine objects are hosted by a platformobject that resides at the lowest of the three layers. Each platformobject, launched by a bootstrap object at yet an even lower layer. Theplatform object corresponds a physical computing system (including anoperating system) upon which application and engine objects execute.Thus, application objects need only establish a proper, standardized,relationship to a hosting application engine object. Aspects of thesupervisory control and manufacturing information system relating tophysical computing devices and their operating systems are handled bythe engine and platform object configuration. The physical topology ofthe system and the application's physical location is transparent to theoperation of the application objects.

The disclosed layered hosting arrangement of object enables asupervisory process control application to be modeled independently ofthe computing hardware and supervisory control network topology, uponwhich the application executes. Isolating the application model from thephysical deployment configuration enables migrating applications tonew/different computing systems as the need arises and to keep up withunderlying hardware changes over the course of the life of theapplication. Such capabilities are especially beneficial in the area ofprocess control and manufacturing information systems where pilotinstallations are used to provide proof of concept and then theapplication grows as, and when, it is justified.

The application model includes groupings of application objects withinlogical containers referred to as “areas.” All application objectswithin a same area must be deployed upon a same application engineaccording to a software deployment scheme. However, the layeredapplication architecture enables binding an application model to aparticular deployment model at a late stage in development. Thus, anabstract “area” need not be associated with a particular engine until adeveloper is ready to deploy and execute a supervisory-level system.

The security model for a supervisory control and manufacturinginformation system is independent of the physical hardware, and thus asupervisory process control and manufacturing information systemarchitect need not bind security to a particular physical systemcomponent until the application modules have been deployed within aphysical system containing the physical system component. The latebinding of security to particular components of a system enables adeveloper to determine the authorization of a particular system basedupon the deployed application objects, and the developer binds securitybased upon the functionality of the application objects deployed uponparticular computing nodes.

Furthermore, disassociating the functionality (business logic) providedby the application objects from the computer systems upon which theexecute enables presenting the defined system/software configurationaccording to a plurality of views/models. A “plant centric” applicationmodel enables a system developer to build an application model in alogical way. The system developer defines the individual devices andfunctions as distinct entities within a plant. All associatedfunctionality is contained in each object. After defining the individualobjects within the plant, the user configures (assembles) associationsbetween the objects.

The application model is a logical build of the plant relative tophysical areas of the plant and the equipment and functions within thephysical areas. The engineer configures the behavior and associationbetween these plant area entities. The supervisory process control andmanufacturing information system provides a configuration view of theapplication model depicting a containment hierarchy with relation to:the areas and equipment, and the equipment itself.

The application model supports containing objects within objects, andcontainment can be specified in a template. Containment facilitatesleveraging the work of different engineers at different levels ofdevelopment of a supervisory process control and manufacturinginformation application. A particular technician can define the detailsfor a particular low level device. Thereafter another engineer defines aunit or other device in the application that contains one or moreinstances of the particular low level device.

The application model also supports propagating changes throughinheritance. Thus, child objects inherit changes to a referenced parenttemplate definition.

After a developer specifies the functionality of a process control andmanufacturing information application, the application is deployedacross potentially many physical computing systems. In an embodiment ofthe invention disclosed herein, a second type of system view, referredto as a deployment model, enables a user to configure physical PCs anddevices with regard to an application. The deployment model defines: PCsand engine types that run on the platforms, and external deviceintegration. A user defines the areas that will run on particularengines, thereby determining where the particular application softwarewill be physically executed. The supervisory process control andmanufacturing information system provides a configuration view of adeployment model showing the hierarchy with physical PCs, and the areasand application objects running on the physical PCs. After a developerdesignates/confirms the deployment model, the application objects andengine objects are deployed on the physical computing devices accordingto the deployment model.

In accordance with an aspect of the disclosed embodiment of the presentinvention, software components are distributed to appropriate computersfrom a centralized location via a network. This reduces the workloadplaced upon engineers/network software maintenance personnel whenconfiguring the software on the various computers that execute adistributed application. Furthermore, only the software required tocomplete an installation is transmitted (i.e., previously existingcomponents are not sent to the remotely loaded computers). Finally, theconfiguration of the remote computers is checked against therequirements specified to carry out the deployed software.

Yet another aspect of an embodiment of the present invention is theability of the object communication links to self-heal when an object ismoved to a new location in the network. In such case, the name remainsthe same. As a consequence, the calling object consults a name bindingdirectory service that furnishes a new self-routing communicationshandle for the moved object. To application objects, that addressobjects on a name basis, the move of the called object is transparent.

Still yet another aspect of the disclosed embodiment of the presentinvention is the use of the messaging capabilities of the system toprovide attribute data access via a set of snap in software modules to acentral diagnostic facility including a graphical display interface. Inan exemplary embodiment of the invention disclosed herein below, thediagnostics in the supervisory process control and manufacturinginformation system are centralized through the use of a GUI-basedmanagement shell and an extensible set of snap-in software modules thatretrieve diagnostic information from remotely located sources ofdiagnostic data. Thus, a user is capable of gaining access to thedistributed diagnostic data within a system by calling up a singleapplication (e.g. a Systems Management Console or “SMC” described hereinbelow).

The GUI-based management shell hosts an extensible set of snap insoftware modules relating to various diagnostic monitoring/managementtasks. The particular “snap ins” search the network for applicablesystem objects and diagnostic data (attributes). The data is thenpresented to the management shell for presentation via the shell'sgraphical user interface.

Having summarized generally the new architecture for a supervisoryprocess control and manufacturing information system facilitatingre-configuring (re-architecting) the system, attention is directed toFIG. 1, comprising an illustrative example of a system incorporating anapplication architecture embodying the present invention. A firstapplication server personal computer (PC) 100 and a second applicationserver PC 102 collectively and cooperatively execute a distributedmulti-layered supervisory process control and manufacturing informationapplication comprising a first portion 104 and second portion 106. Theapplication portions 104 and 106 include device integration applicationobjects PLC1Network and PLC1, and PLC2Network and PLC2, respectively.The PLCxNetwork device integration objects facilitate configuration of adata access server (e.g., OPC DAServers 116 and 118). The PLC1 and PLC2device integration objects, operating as OPC clients, access datalocations within the buffers of the OPC DAServers 116 and 118. The dataaccess servers 116 and 118 and the device integration objectscooperatively import and buffer data from external process controlcomponents such as PLCs or other field devices. The data buffers areaccessed by a variety of application objects 105 and 107 executing uponthe personal computers 100 and 102. Examples of application objectsinclude, by way of example, discrete devices, analog devices, fieldreferences, etc.

In accordance with an embodiment of the present invention, applicationengines host the application objects (via a logical grouping objectreferred to herein as an “area”. The engines are in turn hosted byplatform objects at the next lower level of the supervisory processcontrol and manufacturing information application. The applicationportions 104 and 106 are, in turn hosted by generic bootstrap components108 and 110. All of the aforementioned components are described hereinbelow with reference to FIG. 2.

In the exemplary system embodying the present invention, themulti-layered application comprising portions 104 and 106 iscommunicatively linked to a controlled process. In particular, the firstapplication server personal computer 100 is communicatively coupled to afirst programmable logic controller 112, and the second applicationserver personal computer 102 is communicatively coupled to a secondprogrammable logic controller 114. It is noted that the depictedconnections from the PCs 100 and 102 to the PLCs 112 and 114 representlogical connections. Such logical connections correspond to both directand indirect physical communication links. For example, in a particularembodiment, the PLC 112 and PLC 114 comprise nodes on an Ethernet LAN towhich the personal computers 100 and 104 are also connected. In otherembodiments, the PLCs 112 and 114 are linked directly to physicalcommunication ports on the PCs 100 and 102.

In the illustrative embodiment set forth in FIG. 1, the PCs 100 and 102execute data access servers 116 and 118 respectively. The data accessservers 116 and 118 obtain/extract process information rendered by thePLC's 112 and 114 and provide the process information to applicationobjects (e.g., PLC1Network, PLC1, PLC2Network, PLC2) of the applicationcomprising portions 104 and 106. The data access servers 116 and 118are, by way of example, OPC Servers. However, those skilled in the artwill readily appreciate the wide variety of custom and standardized dataformats/protocols that are potentially carried out by the data accessservers 116 and 118. Furthermore, the exemplary application objects,through connections to the data access servers 116 and 118, represent aPLC network and the operation of the PLC itself. However, theapplication objects comprise a virtually limitless spectrum of classesof executable objects that perform desired supervisory control and dataacquisition/integration functions in the context of the supervisoryprocess control and manufacturing information application.

The supervisory process control and management information applicationis augmented, for example, by a configuration personal computer 120 thatexecutes a database (e.g., SQL) server 122 that maintains a supervisoryprocess control and management information application configurationdatabase 124 for the application objects and other related informationincluding templates from which the application objects are rendered. Theconfiguration database 124 also includes a global name table 125 thatfacilitates binding location independent object names tolocation-derived handles facilitating routing messages between objectswithin the system depicted in FIG. 1. The configuration PC 120 andassociated database server 122 support: administrative monitoring for amulti-user environment, revision history management, centralized licensemanagement, centralized object deployment including deployment andinstallation of new objects and their associated software, maintenanceof the global name table 125, and importing/exporting object templatesand instances.

Actual configuration of the applications is carried out via anIntegrated Development Environment (IDE) 127 that communicates with thedatabase server 122 via distributed component object model (DCOM)protocols. The IDE is a utility from which application objects areconfigured and deployed to the application server PCs 100 and 102.Developers of a supervisory process control and manufacturinginformation application, through the IDE, carry out a wide variety ofsystem design functions including: importing new object and templatetypes, configuring new templates from existing templates, defining newapplication objects, and deploying the application objects to the hostapplication engines (AppEngine1 or AppEngine2 in FIG. 1) on theapplication server PCs 100 and 102.

The exemplary supervisory control network environment depicted in FIG.1, also includes a set of operator stations 130, 132, and 134 thatprovide a view into a process or portion thereof, monitored/controlledby the supervisory process control and management informationapplication installed and executing as a set of layered objects upon thePCs 100 and 102. A RawMaterial PC 130 provides a representative viewenabling monitoring a raw materials area of a supervised industrialprocess. A ProductionPC 132 presents a representative view of aproduction portion of the supervised industrial process. AFinishedProductPC 134 provides a representative view of an area of aproduction facility associated with finished product. Each one of theoperator stations 130, 132, and 134 includes a bootstrap host for eachof the particular operator station platforms. Each one of the operatorstations 130, 132, and 134 includes a view engine that process graphicsinformation to render a graphical depiction of the observed industrialprocess or portion thereof.

It is noted that the system depicted in FIG. 1 and described hereinaboveis merely an example of a multi-layered hierarchical architecture for asupervisory process control and manufacturing information system. Thepresent invention is not limited to the particular disclosedapplication/system. For example it is contemplated that themulti-layered application approach is applicable, at a lower controllevel, to a distributed control system (DCS) application or aprogrammable logic controller (PLC) application. In these cases specificplatform and application engine objects are developed for the uniquecomputing hardware within the DCS or PLC. It is further noted that FIG.1 is presented as a logical view of the interrelations between installedsoftware and physical computing hardware and is not intended todesignate any particular network topology. Rather the present inventionis suitable for a virtually any network topology. In fact, the presentinvention is applicable to a control application running on a singlecomputer system linked to a controlled process.

Turning now to FIG. 2, a class diagram depicts the hierarchicalarrangement of layered software associated with a computer executing atleast of portion of a supervisory process control and manufacturinginformation application. Each computer executes an operating system 200,such as MICROSOFT's WINDOWS at a lowest level of the hierarchy. Theoperating system 200, hosts a bootstrap object 202. The bootstrap object202 is loaded onto a computer and activated in association with startupprocedures executed by the operating system 200. As the host of aplatform class object 204, the bootstrap object 202 must be activatedbefore initiating operation of the platform class object 204. Thebootstrap object 202 starts and stops the platform class object. Thebootstrap object 202 also renders services utilized by the platformclass object 204 to start and stop one or more engine objects 206 hostedby the platform class object 204.

The platform class object 204 is host to one or more engine objects 206.In an embodiment of the invention, the platform class object 204represents, to the one or more engine objects 206, a computer executinga particular operating system. The platform class object 204 maintains alist of the engine objects 206 deployed on the platform class object204, starts and stops the engine objects 206, and restarts the engineobjects 206 if they crash. The platform class object 204 monitors therunning state of the engine objects 206 and publishes the stateinformation to clients. The platform class object 204 includes a systemmanagement console diagnostic utility that enables performing diagnosticand administrative tasks on the computer system executing the platformclass object 204. The platform class object 204 also provides alarms toa distributed alarm subsystem.

The engine objects 206 host a set of application objects 210 thatimplement supervisory process control and/or manufacturing informationacquisition functions associated with an application. The engine objects206 initiate startup of all application objects 210. The engine objects206 also schedule execution of the application objects 210 with regardto one another with the help of a scheduler object. Engines registerapplication objects with a scheduler for execution. The schedulerexecutes the application objects relative to other application objectsbased upon the configuration specified by an engine. The engine objects206 monitor the operation of the application objects 210 and placemalfunctioning ones in a quarantined state. The engine objects 206support check pointing by saving/restoring changes to a runtimeapplication made by automation objects to a configuration file. Theengine objects 206 maintain a name binding service that bind attributereferences (e.g., tank1.value.pv) to a proper one of the applicationobjects 210.

The engine objects 206 ultimately control how execution of applicationobjects will occur. However, once the engine objects 206 determineexecution scheduling for application objects 210, the real-timescheduling of their execution is controlled by a scheduler 208. Thescheduler supports an interface containing the methodsRegisterAutomationObject( ) and UnregisterAutomationObject( ) enablingengine objects 206 to add/remove particular application objects to/fromthe schedulers list of scheduled operations.

The application objects 210 include a wide variety of objects thatexecute business logic facilitating carrying out a particular processcontrol operation (e.g., turning a pump on, actuating a valve), and/orinformation gathering/management function (e.g., raising an alarm basedupon a received field device output signal value) in the context of, forexample, an industrial process control system. Examples of applicationobjects include: analog input, discrete device, and PID loop. A class ofapplication objects 210, act upon data supplied by process controlsystems, such as PLCs, via device integration objects (e.g., OPCDAServer 118). The function of the integration objects is to provide abridge between process control/manufacturing information sources and thesupervisory process control and manufacturing information application.

The application objects 210, in an exemplary embodiment, include anapplication interface accessed by engine objects and schedulers. Theengine objects access the application object interface to: initialize anapplication object, startup an application object, and shutdown anapplication object. The schedulers use the application object interfaceto initiate a scheduled execution of the application object.

Having described the primary components of the hierarchically arrangedsupervisory process control and manufacturing information application,attention is now directed to FIGS. 3-7 that identify attributes ofprimitives that make up the above-described object structures. Turningfirst to FIG. 3 depicts a common object primitive definition. The commonprimitive is incorporated into all the application objects (i.e.,platform, application engine, scheduler, application, etc.). A scriptsattribute 300 is used to keep track of scripts that are associated withan application object. The scripts attribute 300 includes scriptsinherited from templates as well as scripts created specifically for theparticular object type. A UDA (user defined attribute) attribute 302references inherited and new user defined attributes for an object. Analarm mode attribute 304 indicates whether an alarm is enabled and theextent to which it is enabled. A based on attribute 306 identifies aparticular base template from which an object was derived. Attribute 308stores a string identifying attribute names in an object. A containedname attribute 310 identifies the name assigned to an object within acontainer. For example, an object may correspond to a “level” containedwithin a “reactor” object. A deployed version attribute 312 stores aninteger identifying a version for a deployed object. A derived fromattribute 314 identifies the actual template from which an object wasderived. The contents of the derived from attribute 314 differ from thecontents of the based on attribute 306. The based on attribute 306 isthe base template from which this object was derived from. The derivedattribute 314 is the immediate template from which this object wascreated. For example for a hierarchy of templates as follows:

$DiscreteDevice

-   -   $Pump        -   Pump001            $DiscreteDevice is the base template from which a new            template $Pump is derived. An instance Pump001 is created            from the template $Pump. The attribute “derived from” for            object Pump001 will be $Pump. The attribute “based on” for            object Pump001 will be $DiscreteDevice.

A relative execution order attribute 316 identifies another object withwhich a present object has a relative execution order relation. Inaddition to identifying another object, attribute 316 identifies therelative order of execution of the objects (e.g., none, before, after,etc.). The relative execution order information is utilized to scheduleexecution of application objects. A hierarchical name attribute 318stores a full name for an object including any of the containers of theobject (e.g., Reactor1.level). An IsTemplate attribute 320 indicateswhether the object is a template or an object instantiated from atemplate. An AlarmInhibit attribute 322 within an area or containerobject provides cutout functionality to inhibit alarms for all objectswithin an area or container. An alarm mode attribute 324 specifies thecurrent alarm mode of an object. The mode is based upon the object'scommanded mode if area and container are enabled. Otherwise, the mostdisabled state of the container or parent area applies. Alarm ModeCommand attribute 326 specifies the object's currently commanded alarmmode.

The illustrative example of the present invention supports an objecthierarchy. Objects specify such hierarchy in the context of aplant/model view in an area attribute 328 that specifies an area towhich an object belongs. A container attribute 330 specifies a containerthat contains the object. As previously explained, a hostingrelationship exists among various deployed objects. In particular, aplatform hosts an engine, and an engine (via an area) hosts applicationobjects. Thus, a host attribute 338 identifies an object's host.

A category attribute 332 specifies a class of objects with which theobject is associated, thereby facilitating organizing objects accordingto local associations and/or functionality. The value is one of thecategories named in a category enumeration attribute 334. An errorattribute 336 identifies errors generated by the object. An InAlarm flag340 stores a Boolean flag indicating whether an alarm exists in anobject. The flag is true only if a Scan State flag 342 is true (theobject is on scan) and the object's alarms are enabled. The scan stateof an object is changed through a Scan State Command 344 that signalswhether to take the object on/off scan.

A security group 346 enables designating a particular security group forthe object to limit access/use of the object to particular classes ofusers. A description attribute 348 provides an area to store a shortdescription of an object. A tag name attribute 350 specifies a uniquetag for an object. A warnings attribute 352 lists any warnings renderedby an object.

Having described the common attributes of all objects described herein,a set of object type-specific attributes are described herein belowbeginning with attributes for a platform primitive with reference toFIG. 4. The attributes identified in FIG. 4 relate to supporting theobject/engine/platform hosting hierarchy. While not identified in FIG.4, a set of attributes are provided through the platform primitiveenabling platform objects to monitor/report computer device statistics.Other attributes included in the exemplary platform primitive, but notincluded in FIG. 4, concern detecting and reporting alarms associatedwith computer device statistics and storing the statistics.

A RegisterEngine attribute 400 stores a command to register a newengine. The RegisterEngine attribute 400 is used at deployment time toregister an engine with a host platform. A StartEngine attribute 402stores a command to start a particular deployed engine on the platform.A StartHostedObjects attribute 404 stores a command passed to theplatform to start all hosted engines that are start auto and startsemi-auto type engines. A StopEngine attribute 406 stores a command tostop a particular deployed engine on the platform. An UnRegisterEngineattribute 308 stores a command to un-deploy a previously deployed engineon the platform. An Engines attribute 410 stores a list of all enginesdeployed on the platform. An EngineStates attribute 412 stores a list ofthe current operational states of all engine objects hosted by theplatform.

FIG. 5 summarizes a set of attributes associated with an engineprimitive. An external name attribute 500 stores a string used forexternal reference. An internal name attribute 502 stores a string usedfor internal reference. A reference count attribute 504 stores thenumber of objects referencing the engine object. When the number ofreferences reaches zero, there are no clients, external to the engine,referencing any automation object attributes on the engine. This helpsoperators determine the impact (how many clients will be affected) ofstopping the engine. An object attribute 506 is an array comprising aset of all objects hosted by the engine object. A startup type attribute508 identifies how an engine object will be started (e.g., automatic,semi-automatic, manual). A CanGoOnscan attribute 510 indicates whetheran engine object can be placed on-scan. A BindReference attribute 512 isa command used to resolve references (e.g., pump001.inlet.PV) tohandles. These handles are used to locate objects at runtime by themessaging infrastructure. An AutoRestart attribute 514 stores a Booleanvalue indicating whether the engine object should be automaticallyrestarted upon detection of a failure. A CheckpointFailedAlarm attribute516 stores a value indicating whether a last attempt to checkpointhosted objects had failed during a last attempt. An AlarmThrottleLimitattribute 518 stores a value, in alarms per second raised by an engineobject before throttling of alarms generated by objects on the enginewill occur. An EngineAlarmRate attribute 520 indicates the number ofalarms registered on an engine during a last complete scan. AnAlarmsThrottled attribute 522 indicates that an engine object throttledalarms during the last scan.

A set of attributes is provided to handle script execution. AScriptExecuteTimout attribute 524 stores a time limit for a synchronousscript to complete execution before an alarm is raised by an engineobject. A ScriptStartupTimeout attribute 526 stores a time limit for asynchronous script to startup before an alarm will be raised. AScriptShutdownTimout attribute 528 stores a time limit for a synchronousscript to shutdown before an alarm will be raised. A PublisherHeartbeatattribute 530 stores a value corresponding to the number of seconds anengine object will wait for a heartbeat message from another engineobject before it assumes the engine has failed. A Process ID 532identifies a unique identification assigned to an engine process.

An engine object also contains a set of command attributes associatedwith managing application objects. A CreateAutomationObject attribute534 is a command attribute for creating an application object. ADeleteAutomationObject attribute 536 is a command attribute for deletingan application object. A StartHostedObjects attribute 538 is a commandattribute for starting hosted application objects.

Turning to FIG. 6, a set of attributes is summarized that are containedwithin a scheduler primitive and are unique to a scheduler object. Eachscheduler object includes internal and external name attributes 600 and602. A StatsAvgPeriod 604 stores a value representing the averagingperiod for the scheduler acquiring statistics stored within theattributes described herein below. A CheckpointPeriodAvg attribute 606identifies the current average of times between checkpoints during thecurrent averaging period. An ExecutionTimeAvg attribute 608 stores avalue representing the amount of time to execute all the objects perscan cycle. A HousekeepingTimeAvg attribute 610 stores a valuecorresponding to the average time per cycle to complete housekeepingoperations. A TimeIdleAvg attribute 612 stores a value representing theaverage idle time per period. A TimeIdleMax attribute 614 stores a valuerepresenting the maximum idle time recorded. A TimeIdleMin attribute 616stores a value representing the minimum idle time recorded. AnInputMsgSizeAvg attribute 618 stores an average input message size overthe averaging period. An InputMsgsProcessedAvg attribute 620 stores avalue representing the total volume of messages processed, in bytes, perscan cycle during the averaging period. An InputMsgsQueuedAvg attribute622 stores the average number of messages queued per scan cycle duringthe averaging period. An InputMsgsQueuedMax attribute 624 stores themaximum average stored in attribute 622 since the last time thestatistics attributes were reset.

An InputQueueSizeMaxAllowed attribute 626 stores the maximum allowedsize of queued messages in a network message exchange input queue. AnInputQueueSizeAvg attribute 628 stores an average size of the inputqueue in bytes during the averaging period. An InputQueueSizeMaxattribute 630 stores the maximum average stored in attribute 628 sincethe last time the statistical attributes were reset.

A TimeInputAvg attribute 632 stores a value representing the averagetime required, during the current period, to process an input message.An ObjectCnt attribute 634 stores a count value corresponding to thecurrent number of application objects currently being handled by ascheduler object. An ObjectsOffScanCnt attribute 636 indicates thenumber of application objects that are currently off-scan. ATimeOutputAvg attribute 638 stores an average amount of time required toprocess output message during a cycle. A StatsReset attribute 640indicates an request to reset the statistical attributes described forthe scheduler that are not regularly reset (e.g., maximum values). AScanCyclesCnt attribute 642 stores a value indicating the number ofcycles since a last resetting of the attributes through the StatsResetattribute 640. A ScanOverrunsCnt attribute 644 indicates the number oftimes, since a last StatsReset, that a scan cycle ended withoutcompleting a scan of all objects. A ScanOverrunsConsecutiveCount 646stores a current number of consecutive cycles where an overrun occurs. AScanOverrunHighLimit attribute 648 stores a high alarm limit forconsecutive overruns to trigger an alarm stored in aScanOverrunCondition attribute 650. A ScanPeriod 652 stores a valuerepresenting the cycle time for the scheduler.

It is noted that the attributes associated with particular object typesare not limited to the particular object primitive types. In fact, allobject types comprise at least two of the above-described primitives.All object types utilize the common object primitive. In addition, aplatform object includes the attributes of the scheduler, engine andplatform primitives described above. An engine object includes theattributes of the scheduler, and the engine primitives.

Turning to FIG. 7, a set of primitives is associated with an applicationobject. Each type of application object has its own set of primitives.The primitives contain the business specific logic and the set ofattributes that are unique to the function of the primitives. Theseprimitives can be reused across different application object types.

An exemplary set of primitives associated with an analog deviceapplication object is depicted in FIG. 7. A primitive 700 labeledAnalogDevice attributes contains a set of analog device specificattributes in which clients would be interested. A PV.Input 701 is aprimitive that reads, via a device integration object (e.g., PLC1), thedata from a field device. A PV.Output 702 is a primitive that writes,via a device integration object, data to the field. A Scaling 703 is aprimitive that performs linear or square root scaling of the data readfrom the input primitive (PV.Input 701). A LevelAlarms 704 is aprimitive that generates alarms if a process variable in theAnalogDevice primitive 700 exceeds or is below configured values. APV.RoC 705 is a primitive that generates alarms if a PV increases ordecreases faster than a preset limit. A SP 706 is a primitive thatclients write to when they want to modify the value to which thePV.Output 702 writes. A PVDev 707 is a primitive that is used togenerate an alarm if a value read in from a field device (via primitive701) deviates from a value written to the field device (via primitive702) by a certain amount. A CtrlTrack 708 is a primitive that is used toenable the setpoint and PV primitives to track changes driven from theexternal device. Having described the basic building blocks of ansupervisory process control and manufacturing information applicationembodying the present invention, attention is directed to a set ofsequence diagrams that summarize methods employed to carry out such anapplication. Turning to FIG. 8, a sequence diagram depicts steps for thestarting and stopping an application embodying a hierarchical hostingrelationship. During stage 800, a bootstrap process on a computer systemissues a start platform request to a loaded platform object. Inresponse, during step 802 the platform process issues a call to thebootstrap interface requesting the bootstrap to start all theapplication engines hosted by the platform object. During stage 804, thebootstrap process creates an application engine object having theattributes discussed hereinabove.

During stage 806, the application engine process starts all of itshosted application objects. The application engine also registers thehosted application objects with a scheduler process during stage 808.Registering an application object adds that application object to theset of application objects that the scheduler scans during each scancycle. At stage 810, the application engine issues a command to thescheduler to begin executing/scanning the started and registeredapplication objects. Thereafter, at stage 812 the scheduler executes theregistered application objects. Such execution is performed periodicallyduring each scan cycle.

The scheduler continues to periodically scan the registered applicationobjects in accordance with a supervisory process control andmanufacturing information system application until receiving a shutdowncommand. In particular, the bootstrap process, during stage 814, issuesa shutdown command to the platform process in response to an operatingsystem shutdown command. During stage 816, the platform process returnsa stop engine command to the bootstrap to commence shutting down allengines hosted by the platform process. In response, during stage 818the bootstrap issues a request to the application engine to stop. Thebootstrap will wait for the application engine to stop. However, after aperiod, if the application engine has not stopped, the bootstrap willrequest the operating system to shut down the application engineprocess.

Under normal operating conditions, during stage 820 the applicationengine issues a command to the scheduler to un-register the engine'shosted application objects. Furthermore, in an embodiment of theinvention, the engine requests to its hosted application objects to shutdown. However, in alternative embodiments of the invention the shutdownrequest is issued by the scheduler in response to the un-registercommand.

It is noted that in the above-described exemplary embodiment, the engineobjects and platform objects communicate with the bootstrap process andhandle aspects of the supervisory process control and manufacturinginformation application relating to physical computing deviceconfigurations upon which the application executes. However, theapplication objects themselves only communicate with the engine andscheduler according to a platform-independent interface. The one or moreengine objects hosting the application objects insulate the applicationobjects from characteristics of the computer systems upon which theapplication objects execute. Thus, the application objects executeindependently of the physical computing device configurations. Theapplication objects, though constrained to execute on a same engine withother application objects designated within a same area, are notconstrained by any requirement to execute upon a particular one ofmultiple capable engines and/or platforms within a system. Thus, movingan area comprising a set of application objects is performed withminimal interruption to the execution of other application objectsrunning on the affected engines.

Turning to FIG. 9, a sequence diagram illustrates the operationalindependence of an application object with regard to its engine objecthost, and the ability to re-deploy an application object upon anotherhost engine. Beginning at stage 900, an engine A issues a start commandto a scheduler A to commence periodic execution/scanning of anapplication object A. During stage 902, the scheduler A periodicallyactivates the application object A to perform its business logic inassociation with an application comprising multiple application objects.

Later, an application engineer decides to migrate the application objectA to an engine B on a different computer platform. One reason to makesuch a change is to reduce computational load on a computer device as asystem grows. The user issues a request to the engine A to removeapplication object A during stage 904. In response, during stage 906 theengine A issues a request to the scheduler A to stop scanning theapplication object A. During stage 908, the engine A issues a command tothe application object A to shut down. The operation of the engine A andscheduler A is otherwise unaffected by the removal of application objectA.

In an embodiment of the invention, the application is spread acrossmultiple computing devices, and each computing device is equipped withthe platform, engine and scheduler objects of the application hierarchythat facilitate executing application objects. The replication oflower-level hosting functionality across multiple hardware platformsprovides a degree of platform independence that enables relocating anapplication object without affecting the operation of the application.Thus, during stage 910 the user adds application object A to engine B ona different computer. During stage 912, the engine B initializes thenewly added application object A. The initialization stage 912 includes,for example, any custom initialization performed by an applicationobject before starting the application object (e.g., initialization ofclass variables, caching interfaces used by the application object,etc.). At stage 914, the engine B issues a start command to theapplication object A. At this point, the object assumes all of itsprimitives have been initialized and it can perform any initialcalculations based on the attributes maintained in these primitives.Engine B registers the executing application object A with a scheduler Bon the new computing platform during stage 916. Thereafter, at stage 918the scheduler B periodically prompts the application object A to executeits business logic. The results of executing application object A arerendered both locally and over a network connecting the engines. Thus,re-locating application object A to engine B does not affect data accessconcerning application object A.

Inter-Object Communications Via Message Exchange

In an embodiment of the present invention, the application objectsreference other objects by logical name rather than physical address.Thus, communications between application objects within a sameapplication, as far as the application objects are concerned, areinsulated from the underlying physical configuration of a networkcontaining the application object. A component of the application,referred to as message exchange, embedded within the platform and engineobjects enables application objects to retrieve (get) and send (set)data from/to other objects located anywhere within a network executingthe distributed application. Message exchange is a peer-to-peercommunication infrastructure that enables specifying a target by logicalname rather than physical network address. The application objects arethus permitted to carry out communications without regard to thephysical location of an intended recipient of a data request. This alsoenables the application object layer of an application to be developedwithout regard to where the application objects are ultimately deployed.In an embodiment of the invention, the message exchange is dividedbetween a local message exchange (LMX) carried out by an applicationengine and a network message exchange (NMX) carried out by a platform toenable named requests to be communicated between computing devicesconnected over a network for carrying out a distributed application. Inyet another embodiment of the invention, the LMX and NMX functionalityis carried out by the engines. This arrangement avoids extra,inter-process communications required in the event that the platformobject carries out NMX.

The LMX incorporated into the engine objects (e.g., application engineobjects) provides services enabling application objects to access datamaintained as attributes on other objects. When using LMX services toaccess target data, application objects specify a string representing apiece of data associated with an object (e.g., an attribute specified inthe form of “ObjectB.AttributeA”). With this string, LMX locates thedata associated with the object (potentially requesting NMX servicesprovided by the platform to access a target object located on anothercomputing device in a network). LMX returns the data, associated withthe object, to the application object that requested the data. Inaddition, the message exchange guarantees certification of messagedelivery. Therefore, when application objects send messages to otherapplication objects they receive confirmation that the target of themessage received or did not receive the message.

The LMX of the application engine includes, by way of example, a set ofinterfaces. The set of interfaces comprises: IMxSupervisoryConnectionand IMxUserConnection. The IMxSupervisoryConnection interface definesmethods used by application objects to access information from physicaldevices in a plant. The methods used on this interface comprise:SupervisoryRegisterReference, SupervisoryGetAttribute, andSupervisorySetAttribute. The SupervisoryRegisterReference method iscalled by application objects to inform message exchange that a requestto access a value of an attribute is forthcoming. TheSupervisorySetAttribute method is used by application objects to directmessage exchange to modify the value of the attribute specified in aprevious SupervisoryRegisterReference call. The SupervisoryGetAttributemethod is used by application objects to direct message exchange toretrieve the value of the attribute specified in a previousSupervisoryRegisterReference call.

The IMxUserConnection interface defines methods used by applications tovisualize data retrieved from physical devices in a plant. The methodsused on this interface comprise: UserRegisterReference,UserGetAttribute, and UserSetAttribute. These methods are very similarto the methods of the IMxSupervisoryConnection interface describedhereinabove. One difference is that the methods of the IMxUserConnectioninterface methods cater to user interface clients by allowing dataupdates via a callback mechanism instead of a polled mechanism utilizedby the IMxSupervisoryConnection.

A set of structures is utilized to carry out the functionality of themessage exchange. An MxReference structure is a MICROSOFT ComponentObject Model (COM) object that implements an interface IMxReference,identifies an attribute of an object whose value is to be accessed byapplication objects, and is passed into the methodsSupervisoryRegisterReference, and UserRegisterReference. TheMxReferenceHandle (an integer value) is used by message exchange toprovide application objects a location-transparent means of retrieving avalue referred to by an MxReference. The MxReferenceHandle is returnedto application objects by the message exchange on successful completionof a SupervisoryRegisterReference or UserRegisterReference call. TheMxReferenceHandle is passed in, by application objects, to method callsfor getting and setting attributes such as: UserSetAttribute,UserGetAttribute, SupervisorySetAttribute and SupervisoryGetAttribute.

An MxHandle structure identifies a property of an object's attribute.The MxHandle identifies a platform and an engine to which the objectbelongs. The MxHandle comprises two structures: anMxAutomationObjectHandle and an MxAttributeHandle. TheMxAutomationObjectHandle is the data structure used to represent thelocation of the object within the overall system. The MxAttributeHandledata structure is used to identify the property of an attribute withinthe object. The MxAttributeHandle structure is used, internally, bymessage exchange to quickly locate an attribute of an object.

The MxAutomationObjectHandle data structure includes five fields:galaxy, platform, engine, object, and signature. The galaxy fieldidentifies the general system to which the referenced object belongs. Aplatform field identifies the platform object with which the referencedobject is associated. An engine field identifies the object's engine. Anobject field identifies an object. A signature field stores a valuederived from the object's name and prevents configuration mismatchesthat can occur when an object is relocated.

The MxAttributeHandle data structure includes seven fields: primitiveID,attributeID, propertyID, index1, index2, index3 and signature. TheprimitiveID field identifies a primitive within an automation object. Aprimitive is a helper object that performs a specific operation in, forexample, an application object. The attributeID identifies a particularattribute within an identified primitive. A propertyID identifies aproperty of an attribute. Index fields 1, 2 and 3 provide indexes intoup to a three-dimensional array. A signature field stores a checksumvalue derived from the content of the MxAttributeHandle to preventconfiguration mismatches.

It is noted that the message exchange, in an embodiment of the presentinvention, includes additional data structures and interfaces. Suchadditional interfaces and structures will be known to those skilled inthe art. It is further noted that the present invention is not limitedto systems that utilize message exchange to provide ahardware/deployment independent messaging service for inter-objectcommunications for a set of application objects within a supervisoryprocess control and manufacturing information application.

Multiple Views/Late Binding of a Model to a Deployment

Another aspect of the proposed application architecture is thespecification of associations within objects. The associations,discussed herein below, enable a configuration component, referred toherein as the Integrated Development Environment (IDE) to filter anddisplay a set of related objects in a variety of views including atleast a (logical) model view and a (physical computing) deployment view.The IDE, through its displayed views of an application configuration,enables a user to design and deploy an application in a computer networkcomprising multiple computing devices.

The application configurations are stored as “packages” within theconfiguration database 124. A package framework subsystem provides aninterface enabling the IDE to store and retrieve the objects of thepackages. The package framework employs a relational database to storepackage data and knowledge regarding the objects'associations/relationships with other objects. The IDE queries thepackage framework to deliver a list of objects based on a designatedassociation with regard to an object. For example, the IDE can requestthe package framework to retrieve from a package the objects hosted by anamed engine.

A developer builds the aforementioned associations (or “relationships”)between objects via the IDE and package manager. Such associationsinclude, by way of example, the following pre-defined assignmentrelationships: host, area, container, engine and platform. Each of theserelationships is discussed herein below.

A host relationship is used at runtime to indicate where an objectexecutes. Furthermore, an object may not be deployed unless its host isdeployed. An application object is hosted by an area object, an areaobject is hosted by an engine object, and an engine object is hosted bya platform object. An area relationship establishes a logical groupingof objects and provides a means for collecting events and alarms raisedby objects grouped under the area. A container relationship specifies aloose coupling between two objects and is only meaningful in the contextof the application logic. Example: a Valve object contained inside of aTank object. Contained objects are allowed to acquire hierarchical nameswithin the context of the objects' container. By way of example, a valvethat acts as an inlet is assigned the alias “inlet” and receives thehierarchical name of “Tank.Inlet.” An object's engine is the actualengine that executes the object. An object's platform is the one andonly platform object running on a computer device upon which the objectis deployed. An object may have all five of these relationships, butonly one object may be associated to any one of these relationships. Forexample, an application object can be assigned to one and only one area.

A model view depicts the application in terms of logical associationsbetween plant/process equipment within a controlled plant process—e.g.,a representation of a physical plant layout. A deployment view depictsthe physical computer devices and assignment of instantiated objectsidentified in the model view to the computer devices and enginesexecuting upon the computer devices. A derivation view depicts thesources (inherited property relationships from base template toinstance) of objects instantiated from templates to carry out thefunctionality of the model view elements.

FIG. 1 shows, by way of example, an application physically deployed totwo application server computers 100 and 102. Alternatively, anapplication is presented to users by visually depicting the role ofapplication objects in carrying out supervisory process control and/orextracting manufacturing information according to the application.Turning now to FIG. 10 a plant process application is depicted, in aplant model, according to the roles of application objects in the plantprocess. This illustrative example is scaled down for purposes ofillustratively depicting an exemplary embodiment of the invention. Asthose skilled in the art will readily appreciate, the present inventionis applicable to a wide variety of industrial/plant monitoring/controlapplications that are far more complex than this example.

A hopper H1 1000 having a controlled outlet valve delivers raw productto a conveyor C1 1002 that is controllable to travel left, right, or bedisabled. The raw product is dumped by the conveyor C1 1002 into a mixerM1 1004 and a mixer M2 1006. The raw product is allowed to pass into themixers by opening valve V1 1012 and V2 1014 of mixer M1 1004 and mixerM2 1006, respectively. The mixer M1 1004 and mixer M2 1006 include acontrollable agitator A1 1008 and A2 1010 respectively. The mixedproduct drops into hoppers H2 1016 and H3 1018. The hoppers H2 1016 andH3 1018 are selectively opened to allow the mixed product to fall upon aconveyor C2 1020 that either travels right or is disabled. When enabled,the conveyer C2 1020 drops the mixed product onto an elevator E1 1022.The elevator E1 1022 deposits the mixed product onto a conveyer C3 1024that travels right. The conveyor C3 1024 deposits the material onto adistribution conveyor C4 1026 that is capable of traveling both left andright thereby distributing the mixed product between a first bi-statedoor D1 1028 and a second bi-state door D2 1030. The door D1 1028 iscontrollable to direct finished product into either bin B1 1032,or B21034. The door D2 1030 is controllable to direct finished product intoeither bin B3 1036 or bin B4 1038.

While the above-described process line depicted in FIG. 10 is simple,and thus relatively easy to follow, in most cases processes are verycomplex and include hundreds and even thousands of distinct, sensors andcontrolled components. In such instances, the application objectscorresponding to the sensors and controlled components are logicallygrouped within areas. The logical grouping of application objects isexploited during runtime to provide a uniform treatment of particularapplication objects for alarm and event management. For example, allalarms in a particular area can be disabled by a single attributedesignation within the area object. The compatibility of the host areaand hosted objects is determined by checking the “required hostfeatures” of the hosted object and the “supported features” specified bythe hosting area object. These object attributes are established whenthe objects are built. If the “required host features” are met by the“supported features,” then the host assignment is completed by assigningappropriate values to hosted objects. An object is placed within an areaby designating the area name in the area attribute 328 of the commonprimitive of an application or area object.

Areas themselves can be grouped within other areas in a hierarchicalarrangement. Assigning an area to another “host” area is accomplished,by way of example, by designating the name of the host area in the areaattribute 328 of the hosted area object. The relationship between areasand sub-areas are not constrained to execute on a same engine. Thus,sub-areas within an area can be assigned to different applicationengines when the application objects of a supervisory process controland manufacturing information application are deployed within a systemcomprising multiple platform objects (corresponding to multiple computerdevices) and engine objects. However, in an embodiment of the invention,application objects specified within a sub-area are restricted todeployment on a same application engine. This restriction ensures thatprocessing of all application objects in an area occurs withoutinter-node communication delays.

Area objects, by way of example, include the following attributes thatfacilitate the above-described functionality: alarm information, disableall alarms, disable the display of all alarms, sub-area list.

Turning to FIG. 11, logical grouping of related process components ofFIG. 10 into areas is demonstrated. The revised process illustrationdepicts the system as a series of areas comprising logically groupedcontrolled process components. A raw material store area 1100 includesthe hopper H1 1000. A production area 1102 includes the conveyor C11002, a line1 area 1104 including the mixer M1 1004, valve V1 1012, andhopper H2 1016, and a line2 area 1106 including the mixer M2 1006, valveV2 1014, and hopper H3 1018. A distribution area 1108 includes theconveyor C2 1020, the elevator E1 1022, the conveyer C3 1024, conveyorC4 1026, bi-state door D1 1028 and bi-state door D2 1030. A finishedproduct store area 1110 includes bins B1 1032, B2 1034, B3 1036 and binB4 1038. The set of sub-areas are grouped under a single process plantarea 1120.

Having described an exemplary plant process and two alternative ways inwhich to view an application relating to the plant process (i.e., plantmodel and application object deployment views), a configuration utilityinterface is described that displays the application componentsaccording to these two alternative views. Turning briefly to FIG. 12, apartially completed model view user interface generated by aconfiguration utility depicts an area hierarchy represented in the formof a tree. The tree structure presents a high-level model view of theareas designated in a process plant depicted in FIG. 11. This model viewis incomplete since it does not identify the application objects groupedwithin the identified areas and containment relationships forapplication objects.

With reference to the exemplary tree structure, a process plant node1200 corresponding to the process plant area 1120 is designated at thehighest level of the hierarchical area representation. A set ofsecondary nodes, corresponding to sub-areas grouped within the processplant area 1120, branch from the process plant node 1200.RawMaterialStore node 1202, Production node 1204, Distribution node 1206and FinishedProductStore node 1208 correspond to the raw material storearea 1100, the production area 1102, a distribution area 1108 and afinished product store area 1110 respectively. A line 1 node 1210 and aline 2 node 1212 branching from Production node 1204 correspond to theline1 area 1104 and line2 area 1106 grouped within the production area1102 in FIG. 11. This view enables a technician to quickly identify andspecify logical groupings for defining policies governing applicationobjects such as alarming behaviors, etc.

Before describing an expanded version of the model view of FIG. 12identifying application objects and compounds within the identifiedareas, derivation of objects from templates is discussed. Each of thecomponents identified in FIG. 10 corresponds to an application object.In an embodiment of the invention, application objects are instantiatedfrom object templates. A derivation view represents all the types oftemplates from which application objects specified by a current modelfor an application are derived.

The set of candidate templates from which application objects arederived is extensible. Users are provided toolkits including basetemplates and editors to define customized new templates from which auser builds application objects. Examples of base templates (where $denotes a template) are: $DiscreteDevice—a state machine that isconfigurable to create an application object representing the mainconveyors and valves depicted in FIG. 10, and $UserDefined—a simpleobject template that contains only the common primitive, and from whichthe user builds extensions within the configuration environment byadding scripts and attributes to model the application objectscorresponding to the bins and hoppers.

Turning to FIG. 13, an exemplary derivation view rendered by aderivation view generated is illustratively depicted. With reference toFIG. 13, in the case of the example set forth in FIG. 10, the userderives from a $DiscreteDevice base template a $Valve, a $SliceGate, a$Agitator, and a $Conveyor custom application object template type.Under the $Conveyor template, the user further defines a$SingleDirectionConveyor, a $BiDirectionalConveyor, and an $Elevatortemplate type. Under a $UserDefined base template the user derived a$Vessel application object template. The $Vessel template is furtherrefined to derive a $Hopper and a $Bin application object. Withreference to FIG. 13, the base templates occupy the highest levels ofthe hierarchical derivation tree that is rendered by a configurationview generator based upon a user's designation of particular templates.Object templates derived from the base templates are identified bybranches leading from the base template nodes. As depicted in FIG. 13,it is possible to derive objects from other derived objects. In suchcases, the children inherit the designated characteristics of theirparent templates. The derivation relationship between a child and itsparent template is registered in the derived from attribute 314 of thetemplate object.

Application object containment (specified in container attribute 330 ofan application object), and the creation of compound object templatesfrom a set of previously defined object templates is another aspect ofthe template architecture disclosed herein. In an embodiment of theinvention, containment is limited to same object types. Thus, areaobjects can only contain area objects and application objects can onlycontain other application objects. Objects containing other objects arereferred to herein as “compounds.” Objects that exist solely to containother objects are referred to as “composites.”

Turning briefly to FIGS. 14 a and 14 b, an example is provided of acompound application object template—in this case a $MixerVesselcompound object template that includes a valve object that is assignedthe tag name “inlet”, an agitator that continues to carry the tag nameof “agitator,” and a mixer that has been assigned the tag name “vessel.”The contained name attribute 310 of the templates corresponding to eachof these three contained objects. The full hierarchical tag name (e.g.,MixerVessel.Inlet) is stored in the hierarchical name attribute 318 foreach of the three contained objects. The container attribute 330 foreach contained object is assigned the string “MixerVessel.” FIG. 14 aschematically depicts a portion of the process plant depicted in FIG. 10that contains a mixer vessel arrangement. A model view of the compoundtemplate showing the containment relationship between the $MixerVesselapplication object template and its contained (renamed) applicationobjects is depicted in FIG. 14 b. In an embodiment of the invention,when instantiated within an actual application, all application objectscontained within a compound application object designate a same host inattribute 338 (and by requirement a same area in attribute 328. Thiscontainment hierarchy, applicable to other objects as well (subject toany deployment restrictions), assists system developers in developingsystems by supporting the creation of logical building blocks(comprising many smaller application objects) from which applicationscan be built.

A “contain” function supported by the IDE, in an embodiment of thepresent invention, facilitates establishing containment relationshipsbetween objects via a graphical user interface “drag and drop”operation. To establish a containment relationship between a source andtarget (container) application object, a developer selects the sourceapplication object displayed on a user interface, drags the sourceapplication object on top of the target (container) object, and thendrops the source application object on the target application object.After the IDE confirms the compatibility between the two objects (i.e.,they are both application objects), the IDE (through the package managerutility) sets the host, area and container attributes in the sourceobject. In particular, the area attribute 328 is set to the targetobject's area, the host attribute 338 is set to the target's host, andthe container attribute 330 is set to the target object's name. At thispoint the contained name attribute 310 and the hierarchical nameattribute 318 of the source are also filled in with names provided bythe developer.

Returning to FIG. 13, the $MixerVessel compound application objecttemplate is assigned a branch under the $UserDefined base template nodeand specifies the contained relationships between the application objecttemplate elements of the compound. Furthermore, a $MixerVessel.Inlettemplate derived from $Valve is placed under the $Valve template node. A$MixerVessel.Vessel template derived from $Vessel is placed under the$Valve template node. A $MixerVessel.Agitator template derived from$Agitator is placed under the $Agitator template node. The containmentrelationship is registered by specifying the $MixerVessel templateobject in the container attribute 330 in each of the compound elements.The containment relationship is indicated in the derivation view tree ofFIG. 13 by a “$MixerVessel” preamble in the $MixerVessel.Inlet,$MixerVessel.Agitator, and $MixerVessel.Vessel object templaterepresentations within the derivation view tree.

Attribute locking and its effect upon change propagation in templatesare yet other aspects of the derivation architecture of the exemplaryconfiguration utilities disclosed herein. The derivation architectureenables information within an object template to be propagated toderived objects or alternatively a default value is specified for aderived template that can be overridden by a developer. In an embodimentof the invention, propagation is affected automatically by storing areference to a parent's copy of a locked attribute.

An attribute in a template or instance can be unlocked, locked inparent, or locked in me. Both templates and instances can have unlockedattributes. An unlocked attribute is read-write, and the object has itsown copy of the attribute value—i.e., it is not shared by derivedobjects. A template, but not an instance can have a locked in meattribute status. In the case of a locked in me attribute, the value isread-write. Derived objects do not get their own copy of the attributevalue, but instead share the locked value by reference to an ancestorwhere the attribute is locked. The status of the attribute in thechildren of a locked in me attribute is “locked in parent.” Thus,changes to the value of a locked in me template attribute propagate toall children. Both templates and instances can have a locked in parentattribute. A locked in parent attribute is read-only.

The interface for getting and setting a locked status of an attribute isexposed to configuration clients. The client obtains a reference to theattribute and sets its locked status. Whether a change to an attributeis permitted and/or propagated to derived children is based upon whethera particular attribute in a template is locked. Locking an attribute hastwo consequences. First, a locked in parent attribute cannot be modifiedin a derived template or instance. Second, a locked in me attribute in atemplate can be changed, and the change is cascaded down through alltemplates and instances derived from the template containing the lockedattribute. On the other hand, if an attribute is not locked, then theattribute specifies a default value that can be overridden in a derivedtemplate. Furthermore, if the value of a non-locked attribute ischanged, then the change is not cascaded to derived templates.

After establishing a set of templates that are to be used for theapplication objects identified in FIG. 10, the application objectinstances are created from the templates according to the proposedsupervisory process control and manufacturing information application.Using the templates defined in FIG. 13 and the exemplary process plantdepicted in FIG. 10 the following application objects are rendered:

$MixerVessel is used for Mixer M1 and M2;

$Hopper is used for Hopper H1, H2 and H2;

$SingleDirectionConveyor is used for conveyors C2 and C3;

$BiDirectionalConveyor is used for conveyors C1 and C4;

$SlideGate is used for Door D1 and D2; and

$Bin is used for Bins B1, B2, B3 and B4

Turning to FIG. 15, a hardware derivation view depicts the sources ofengine and platform objects from object templates. Such a view isbeneficial when deciding where to distribute or re-locate areas thathave particular engine and/or platform requirements. Node 1500corresponds to a WINDOWS operating system-based platform template. A setof platform instances, corresponding to platform objects derived fromthe WINDOWS operating system-based platform template, branch from node1500 and correspond to each of the personal computers identified inFIG. 1. Node 1510 corresponds to an application engine template. A setof application engine instances, derived from the application enginetemplate, branch from node 1510 and correspond to the applicationengines depicted in FIG. 1. Node 1520 corresponds to a view enginetemplate. A set of view engine instances branch from node 1520 andcorrespond to the view engines depicted in FIG. 1. Node 1530 correspondsto a PLCNetwork device integration object template. A set of instancesbranching from node 1530 correspond to device integration objectsidentified in FIG. 1 that support configuring the OPC servers 116 and118. Finally, node 1540 corresponds to a PLCObject device integrationobject template. A set of instances branching from node 1540 correspondsto device integration objects identified in FIG. 1.

FIG. 16 represents a model view of the process application depicted inFIGS. 10 and 11. The model view displays area hosting and containmentrelationships specified by objects (including application objects andareas). The model view identifies the objects that are logically groupedtogether for purposes of describing the plant layout. The model viewenables a user to quickly designate objects that will be treateduniformly under a particular policy (e.g., alarming, etc.). The modelview includes, by way of example, nodes corresponding to the areasdesignated in FIG. 11 and depicted in the area tree structure of FIG.12. The leaves of the tree 1600 identify the application objects andtheir assignments to the identified areas. Furthermore, the model viewtree depicts compound containers such as a set of compound containerobjects MV1 and MV2 instantiated from the $MixerVessel compound template(discussed above with reference to FIG. 13).

The model view is rendered by a model view generator based upon the areaand container attributes of the objects specified under a particularapplication. In an embodiment of the invention, the compatibility of anarea/container with a grouped/contained object is determined when a userseeks to create the association. This compatibility is determined bycomparing the support features of the parent object to the needs of thegrouped/contained child object. Furthermore, in an embodiment of theinvention all objects within a container are required to designate asame area.

Areas can be hierarchical. Thus, an area can include an area, and aparent area collects alarm statistics for all objects in its sub-areas.In a model view hierarchical tree structure depicted in FIG. 16,starting at the highest level of the tree structure, if no area isdesignated for an area object, then the area object (e.g., ProcessPlant1602) is connected directly to the root node (the highest level of thetree). At a next level, sub-areas of the ProcessPlant 1602 (i.e.,RawMaterialStore 1604, Production 1606, Distribution 1608 andFinishedProductStore 1610) are connected as branches under theProcessPlant 1602 node. In the exemplary application model tree 1600,the branches from the sub-areas contain application objects (i.e.,hopper H1, conveyors C1-C4, doors D1-D2, elevator E1, and bins B1-B4),and additional sub-areas (i.e., Line1 and Line 2 in the Production 1606sub-area). The Line1 and Line2 sub-areas both include compounds (i.e.,mixer vessels MV1 and MV2). The leaves of the compounds MV1 and MV2identify the objects contained by the compound objects. In theparticular example, the MixerVessel compound MV1 includes an agitatorA1, a vessel M1 and an inlet valve V1. The MixerVessel compound MV2includes an agitator A2, a vessel M1 and an inlet valve V1.

FIG. 17 represents an exemplary deployment view of the applicationmodel's areas to the hardware and platform depicted in FIG. 1. Thedeployment view visually depicts where the various objects of anapplication execute. A deployment view is therefore rendered based uponthe hosting (attribute 338) and the containment (attribute 330)relationships designated by objects. A child area object is notconstrained to execute upon the same application engine as a specifiedparent area (in attribute 328), and the area relationships designated byobjects are not applied when rendering the deployment view.ApplicationObjects are Hosted (attribute 338) by their area, thereforethe deployment view shows the ApplicationObject relationship to itsarea. Thus, the deployment view (and the actual deployment of nestedarea objects) does not reflect alarm/event concentration and propagationassociated with the hierarchical area model relationships designatedbetween area objects.

The application objects are not displayed in FIG. 17. However, adeployment view generator arranges the application objects underappropriate areas based upon the host/container designations withinthose objects. In an embodiment of the invention, an applicationobject's designated host and area are, by requirement, the same.Therefore, all application objects referencing an area object areexecuted upon a same engine object identified in the host attribute 338of the area object. This requirement ensures that alarms and datamaintained for application objects under a particular area aremaintained locally on a same computer device. If an application objectspecifies a container (compound application object) in attribute 330,then the named container overrides the named area host when generating adeployment view tree (i.e., an application object within a compound(container) is placed under its designated compound name). However, inan embodiment of the invention all application objects contained withina compound are constrained to execute upon a same host (i.e., allcontained application objects acquire the compound/container'sdesignated area).

The deployment view set forth in FIG. 17 is especially appropriatelyclassified as exemplary since the areas and their associated objects arecapable of running on any suitable platform/application enginecombination. The multi-layered platform/engine/area/application objecthosting arrangement renders the various areas (and their associatedapplication objects) capable of installation at any suitable hostingengine branch in the graphical representation of the deployment ofapplication components depicted in FIG. 17. The highest level of thedeployment tree hierarchy identifies a set of platforms corresponding tothe personal computers depicted in FIG. 1. The set of platformsrepresented by nodes include: a RawMaterialPC node 1700, a Production PCnode 1702, a FinishedProductPC node 1704, a ConfigurationPC node 1706,an ApplicationServer1PC node 1708, and an ApplicationServer2PC node1710.

A set of engines is deployed to the platform hosts. The set of deployedengine object nodes corresponding to engine objects hosted by theindicated platform objects includes: a RawMaterialView engine node 1712,a ProductionView engine node 1714, a FinishedProductView engine node1716, an AppEngine1 node 1718, and an AppEngine2 node 1720.

The engines host device integration and area groupings of applicationobjects that are represented in the deployment view as nodes. The set ofdevice integration object nodes corresponding to deployed deviceintegration objects includes PLC1Ethernet node 1722 and PLC1 node 1724,and PLC2Ethernet node 1726 and PLC2 node 1728. The set of area objectnodes corresponding to deployed areas comprising groups of applicationobjects and/or other areas includes a ProcessPlant node 1730, aRawMaterialStore node 1732, a Production node 1734, a Line1 node 1736, aLine2 node 1738, a Distribution node 1740 and a FinishedProductStorenode 1742. The branches connecting the above-identified area nodes totheir associated engines corresponds to the engines designated in thehost attribute 338 in the area objects and their associated applicationobjects that, for the sake of avoiding undue clutter, are omitted fromthe deployment view set forth in FIG. 17.

Another aspect of the above-described application architecture is thetask of actually distributing a configured application to the pluralityof computer devices that execute the configured supervisory processcontrol and manufacturing information application. Since each computerdevice executes a distinct portion of the application, the set ofunderlying software components/modules required on each computer islikely to differ between computers to which the application isdistributed. Furthermore, in an embodiment of the invention,configuration information for an application is maintained separate fromthe executable software that runs on a computer in association with thedistributed objects (e.g., platform object, engine object, area object,container object, application object, etc.) that make up theapplication. The application software and configuration information foreach object of an application are bundled as a set of properties into astructure referred to herein as a package. The software itself is notincluded in the package for an object. Instead, since many objects mayuse a same code module (e.g., an EXE of DLL file), a reference to thesoftware is included in the object package.

A method for deploying a configured application described herein belowincludes steps to ensure that the components needed by a target computerto provide a sufficient software framework for a particular portion ofthe application are transferred from a source to the target computer.Furthermore, if needed software is already present on the targetcomputer, then that software is not transferred. The computer softwareloading operation takes place across a computer network via standardnetwork data communications protocols under the guidance of a user viathe IDE.

By way of example, deployment can occur on an individual objectinstance, on a group of selected object instances, and on a cascadebasis (based upon relationships between a selected instance andhierarchically related objects). The deployment process first checks anddelivers the necessary software and then transfers the objectconfiguration.

Turning now to FIG. 18, in an embodiment of the invention, loadingsoftware onto a remote target computer progresses in the followingmanner. It is noted that as an initial matter, the computers of thenetwork are generically configured with a base operating system andbootstrap layer that support network communications and basicoperational capabilities that facilitate initial loading and start-upand shut-down of the platform layer of the distributed application.Next, during step 1800, a list is compiled of all software referenced byan identified set of objects to be deployed to the target computer. Asmentioned hereinabove, each object includes a reference to the softwaremodules (e.g., EXE and DLL files) required by object. Each of thesereferences is traversed and a covering set of module identifications isestablished. It is noted that the objects themselves identifyprimitives, which in turn reference software modules. It is thereforenecessary to cascade down through all associated sub-components andobjects of an identified object to determine all needed softwaremodules. In an embodiment of the invention, step 1800 is carried out bya deployment server executing on a computer (e.g., Configuration PC 120)that also stores a global set of software modules and the objects thatreference them in the configuration database 124. Upon completing step1800, a covering set of all software required to carry out thefunctionality of the identified set of objects has been created.However, a target computer in many instances already has at least aportion of the supervisory process control application modulesidentified in the list compiled during step 1800. For example, thetarget computer may already have the required software modulesassociated with a platform upon which specialized engines execute.Therefore, the source and target computers cooperatively determine theneeded software modules that are not currently present on the remotecomputer. It is noted that the software modules are separate anddistinct from the configuration information that references thesesoftware modules.

There are many ways to identify which ones of the needed softwaremodules are not currently present on the target computer. Suchvariations include executing comparisons on the target computer oralternatively performing a comparison on a computer (e.g., ConfigurationPC 120) that executes a software deployment server. In an embodiment ofthe invention, the target computer's bootstrap software includes amethod for applying the list of required software modules compiled bythe source during step 1800 to the software modules presently loaded onthe target computer system. Therefore during step 1810 the sourcecomputer transmits a listing of the covering set of required softwaremodules to the target computer in a call to the resident method todetermine the ones of the set of listed modules that are not currentlypresent on the target computer.

Next, during step 1820, the target computer determines which ones of thereferenced software modules in the transmitted list are not present onits system. In an embodiment of the invention, determining which onesare/aren't present is facilitated by a software module registrymaintained by each computer participating in the distributedapplication. The called method on the target computer determines whethereach of the received list of software modules is identified in thesoftware module registry. Alternatively, in the event that such aregistry does not exist, the target computer traverses the directorystructure for identified software modules. The called method marks theones in the received required software module list that are notpresently loaded on the target computer.

After determining which ones of the software modules are needed by thetarget computer, during step 1830 the target computer's method generatesand transmits a return message to the deployment server (or the calleron the method supported by the target computer) identifying which onesof the required software modules are not present on the target computer.After receiving the return message, at step 1840 the deployment serverpackages the “needed” software components identified in the returnmessage from the target computer. The deployment server then transmitsthe software module package to the target computer.

Thereafter, during step 1850 the bootstrap loads the received softwarecomponents into appropriate directories in the target computer system.The loaded software is also registered within a software componentregistry maintained by the operating system. At this point the target PCis ready to receive configuration information (e.g., the objects thatreference the loaded software components) and start up the engines andapplication objects making up a portion of the application.

However, in an embodiment of the invention, before loading aconfiguration, at step 1860 (which can also be performed before step1800 as a preliminary test before loading any software) a proceduresupported by the bootstrap software on the target computer executes asystem verification procedure that ensures that the hardware/systemconfiguration of the target platform (e.g., PC) is sufficient to supportthe loaded modules. By way of example, a platform object may be arrangedto execute upon a particular personal computer operating system andhardware configuration. During step 1860 a method on the target computerqueries the operating system to determine the actual systemconfiguration of the target computer system. If the operating system orhardware (e.g., CPU type, etc.) are incompatible with the platformobject's requirements, then the deployment is blocked and an errormessage is rendered to the user. The breadth of such checks and theresulting actions are varied in accordance with various embodiments ofthe invention. In some instances, corrective action can be takenautomatically (e.g., loading a communications driver). In otherinstances the computer hardware must be upgraded or replaced. In someinstances a recommendation is issued (e.g., additional RAM recommended),but the deployment and execution of the object(s) is notterminated/blocked.

After installing the needed software modules the configurationinformation for the objects is deployed. Deploying configurationinformation to appropriate target computers creates the runtimeinstances of the objects that define and govern the operations of thedistributed supervisory process control and manufacturing informationapplication. Deploying the instances includes activating them in theruntime environment.

Deployment is governed by the hierarchical relationships describedherein above. Thus, a host for a particular object is deployed beforeany of its hosted objects. For example, a platform is deployed prior todeploying any engines on a computer, and an engine is deployed beforeassociated area objects, and an area is deployed before its groupedapplication objects and other embedded areas are deployed.

Application objects communicate with other objects by specifying actions(e.g., Set and Get) upon named attributes within objects. The generalfacilitator of such name-based communications is message exchange.Requests to message exchange, by application objects, to perform actionson other objects include identification information enabling messageexchange to route messages to objects. This identification informationis represented as an MxHandle. An MxHandle is comprised of anMxAutomationObjectHandle and an MxAttributeHandle. TheMxAutomationObjectHandle handle includes fields specifying a platform,an engine, and an object with which the deployed object is associated.The MxAttributeHandle handle includes fields uniquely specifying anobject primitive with which the attribute is associated and theattribute itself. The Configuration Database 124 includes a global nametable 125. The global name table 125 contains a set of subentries foreach object that identify each attribute of the object by name (e.g.,PV) and a corresponding MxAttributeHandle value. In an embodiment of theinvention, properties are statically defined and therefore need not beregistered in the global name table 125 when an object performs namebinding.

Local message exchange residing on each engine maintains a local nametable listing the names and corresponding handles of each objectdeployed on the engine. The local name table facilitates handling aregistration request, for a named object on a same engine as therequestor, rather than going out-of-process to determine a handle. In anembodiment of the invention, when an object is un-deployed, the entrywithin the name tables maintained by message exchange are cleared.

After a deployed objects' configuration information is sent to the hostengine, the object starts up. The startup procedure includes registeringthe application object with a scheduler object associated with theapplication object's application engine. In an embodiment of theinvention each object is individually issued a scan state requestsetting the manner in which the object will be periodically handled bythe scheduler. After completing the registration and setting the scanstate of objects, the attributes are accessible by other objects. Byvirtue of the local and global name tables and the name resolutioncapabilities of the engines' embedded message exchange, a target objectand its attributes are accessible by objects without regard to thetarget object's location on one of the multiple computers executing theapplication with which the target object is associated.

An exemplary sequence of steps depicted in a flowchart depicted in FIG.19 demonstrates the location transparency of an object with regard toother deployed objects seeking to “get” and “set” attributes on theobject via message exchange and underlying inter-process and networkcommunications protocols. Initially, during step 1900 a client1 (e.g.,an application object with a dependency upon data rendered by anotherapplication object) issues a RegisterReference request that identifies atarget object attribute by a location-independent attribute name. Anexample of such an attribute name is pump1.pv. In an embodiment of theinvention inter-object requests are handled via the message exchangefacility which exists within the same process as the engine. Thus, theclient1 RegisterReference request is directed to the local messageexchange on engine1.

After receiving client1's RegisterReference request identifying thepump1.pv attribute, message exchange on engine1 initiates resolving thetarget object attribute name to a message exchange handle. Thus, at step1910 the local message exchange on engine1 determines whether theattribute name corresponds to a name in its local name table identifyingthe objects hosted by the engine1. If the attribute name corresponds toa local attribute, then control passes to step 1920 wherein the localmessage exchange on engine1 determines the MxHandle value assigned tothe object attribute name. Control then passes to step 1950.

On the other hand, if the named attribute does not correspond to a localobject, then control passes from step 1910 to step 1930 wherein themessage exchange of engine1 issues a BindReference request to theconfiguration pc platform 126 that maintains the global name table 125(in the configuration database 124) for the application objects withinan application. The BindReference request includes thelocation-independent name, pump1.pv that the engine1 seeks to resolveinto a corresponding MxHandle.

Next, during step 1940 the configuration pc platform 126 locates thename entry in the global name table 125 and returns the correspondingMxHandle for the named pump1.pv attribute to the engine 1.

After determining the value of the MxHandle, at step 1950 the engine1creates an entry in a reference table that includes at least a referencehandle (an integer value corresponding to the entry in the referencetable corresponding to the name pump1.pv) and the MxHandle value for thenamed object attribute pump1.pv. In an embodiment of the invention, theattribute name is stored in the reference table entry, thereby allowingother objects to request a reference to pump1.pv, and in responsedetermining an MxHandle without consulting either of the name tables.

In an embodiment of the invention, MxHandles are withheld from theapplication objects. Instead, during step 1960 the engine1 returns thereference handle (MxReferenceHandle) to the client1. The referencehandle corresponds to the reference table entry containing the MxHandlefor the referenced object parameter (pump1.pv). In an alternativemethod, the client1 never receives the MxReferenceHandle, and insteadincludes the attribute name with each command. The alternative methodincludes alphabetically re-ordering the object/attribute names tofacilitate quickly locating a reference entry. Alternative ways toshield the MxHandles from clients will be known to those skilled in theart.

After receiving the reference integer value, during step 1970 theclient1 issues a get/set command including the MxReferenceHandle integervalue provided during step 1960. The command is sequentially removedfrom the message exchange queue for engine1, and during step 1980 themessage exchange retrieves an MxHandle from an entry in the referencetable based upon the supplied MxReferenceHandle integer valuecorresponding to the pump1.pv attribute name. The message exchange onthe engine1 forwards the request to the object in the form of a Get/Setattribute command including the MxHandle corresponding to the pump1.pvattribute. The retrieved MxHandle handle provides the needed routinginformation to forward the request to a proper destination applicationobject. In the case where the get/set attribute command refers to alocal, in-process object, the request is handled in-process. Otherwise,the request is handled by a network message exchange (also within theengine1 process space) that processes requests involving objects hostedon other platforms and engines. During step 1985, the pump1 objectreceives and processes the received get/set command. During step 1990the pump1 object returns a response to engine1 that originated therequest on behalf of the client1, and the client1 receives anappropriate response message based upon the request. In particular theresponse includes the original MxReferenceHandle provided by the client1in its request. The response also includes by way of example a piece ofdata, a reference, a completion status, etc. Once the client1establishes a reference to a named attribute (e.g., pump1.pv), thereference persists over subsequent get/set attribute commands.Therefore, steps 1900 through 1960 are executed only once, andthereafter the MxReferenceHandle value for pump1.pv is utilized forsubsequent requests by client1.

The location transparency is particularly advantageous in the context ofrelocating objects to other engines on a system. In such case, onlyengines (that carry out the message exchange functionality) need beconcerned with the changed location of an object. The name of the objectdoes not change when an object moves, and therefore application objectsthat reference a re-deployed object need not perform any procedures toaccommodate a location change by the object. The sequence of callsdepicted in FIG. 20 demonstrate any exemplary scenario where an objectexecuting on a first engine sends a sequence of GetAttribute commands toa second object on the first engine, the second object is relocated to asecond engine, and a new handle is established for the second object onthe second engine, and the second object resumes receiving GetAttributecommands from the first object. The example assumes that object A hasalready established an MxReferenceHandle to an attribute of interestthrough a RegisterReference command to message exchange on the firstengine. The example furthermore assumes that the local message exchangeon engine A has previously obtained an MxHandle for attribute A ofobject B on engine A.

Initially, during step 2000 a scheduler A on engine A activates object Ato perform its business logic (programmed function). In this example,object A's programmed function requires it to retrieve (get) a parametervalue maintained by object B and utilize the value to perform acalculation (e.g., a feedback loop for setting an inlet valve toestablish a particular flow rate from a tank). At step 2002 thescheduler A activates object B to perform its business logic whichincludes establishing a current value for a parameter retrieved byobject A.

During step 2004, object A, in the course of performing its businesslogic, issues a GetAttribute command including an MxReferenceHandlevalue corresponding to attribute A on object B (i.e.,ObjectB.AttributeA). Local Message Exchange (LMX) on engine A retrievesthe GetAttribute command from its LMX queue and during step 2006 passesthe request to object B using the previously established MxHandle forObjectB.AttributeA. At step 2008 object A executes a calculation basedupon the data retrieved from ObjectB.AttributeA.

Next, engine A issues an un-register object B command to the schedulerfor engine A during step 2010, and a shutdown object B command to objectB itself during step 2012, thereby removing the object B from the set ofperiodically executed objects on engine A.

At step 2014 scheduler A again activates object A to perform its periodbusiness logic. At step 2016 object A again issues a GetAttributeObjectB.AttributeA command to LMX on engine A. During step 2018, the LMXon engine A again issues a GetAttribute using the old MxHandle forObjectB.AttributeA—unaware that Object B has moved to Engine B. An errormessage (e.g., InvalidId) is returned to the LMX on engine A. LMX onengine A returns an error message to object A, because of this errorobject A can not complete the execution of its' business logic.

Object B is relocated to Engine B and a new MxHandle is established insteps 2020 and 2022. The Object B executes under scheduler B's commandduring step 2024. LMX on engine A issues a BindReferenceObjectB.AttributeA call to the ConfiguratonPCPlatform in step 2018. Inresponse the ConfigurationPCPlatform returns the new MxHandle forObjectB.AttributeA. In an embodiment of the invention, Object A onengine A can now re-issue its “get” request successfully without knowingthat object B was relocated Engine B.

At step 2026, the scheduler A executes the business logic of object A,and then during step 2028 object A issues a GetAttribute request to LMXon engine A that includes the MxReferenceHandle (for ObjectB.AttributeA)that was established prior to issuing the first GetAttribute command atstep 2004. Thus, even though the location of object B changed, theMxReferenceHandle remains the same. The move of object B to engine B istransparent to the requesting object A, and object A continues to useits previously obtained MxReferenceHandle to submit requests toObjectB.AttributeA. During step 2030 the LMX on engine A forwards therequest to an LMX on engine B (object B's new location) using the newMxHandle for the moved ObjectB.AttributeA. At step 2032, the LMX onengine B retrieves the request from its queue and passes the request toobject B. The value of ObjectB.AttributeA is returned to object A onengine A via the LMX infrastructure, and during step 2034 object Aexecutes its calculation using the retrieved attribute value.

Once the application has been distributed to the computers, acentralized diagnostics management tool provides an interfacefacilitating monitoring the distributed components (e.g., platform,application engine, and application objects) of a supervisory processcontrol and manufacturing information application. Turning to FIG. 21,in an embodiment of the invention, the centralized diagnosticsmanagement tool, referred to herein as a systems management console(SMC) 2100, comprises a management console shell 2102 such as, forexample, the well known MICROSOFT Management Console (MMC). The SMC 2100is the primary human interface for managing a running process controland manufacturing information application and the source of displayedhigh and low level diagnostics for the components of the system depictedin FIG. 1. The management console shell 2102 provides a graphical userinterface comprising a variety of views depicting an assortment ofdiagnostic data and commands that users are capable of asserting uponlinked objects. A set of such views are depicted by way of example inFIGS. 22-23. The functionality of the SMC 2100 is bi-directional in thesense that it gathers data and status of objects, and issues commandschanging data or status of the linked objects. Thus, in addition todisplaying retrieved diagnostic information, the SMC 2100 enables a userto select a graphically depicted representation of an object on one ofthe SMC 2100's supported views and then specify a command or action tobe performed upon the selected displayed object.

The capabilities of an exemplary configuration of the SMC 2100 are asuperset of the management capabilities of a runtime process viewengine, and the set of extended capabilities is open-ended in view ofthe architecture built around an extensible management console shell.Such capabilities include, for example:

-   -   Monitoring error logs generated by platform logging processes.        Sorting and filtering the logging is also supported.    -   Monitoring and tuning-up network and communication performance.    -   Administering platforms and engines—including shutting down and        re-starting the platforms and engines, checkpoint saving,        restoring, and monitoring the status and diagnostic data        rendered by the engines and platforms.    -   Administering configuration and history database archiving and        backup.    -   Administering and monitoring I/O servers also known as Data        Access Servers (DAServers).    -   Administering and monitoring licenses.    -   Adding, deleting, and modifying users based upon user profile        templates.    -   Deploying platforms, engines and application objects in response        to failures.

In and embodiment of the invention the SMC 2100 is deployed with theplatform object for each computer to ensure that all computers usedwithin a system have access to the SMC 2100's functionality. In anembodiment of the invention, the SMC 2100 is not launched when theplatform is deployed. Instead, it is started from a programs option offthe Start menu in an MICROSOFT WINDOWS operating system desktop userinterface. All snap-ins (e.g., object monitor 2106 and diagnosticsextensions 2108, described herein below) are deployed with the platformso that when an update to the SMC 2100 is available, only onere-deployment of the software is required to complete the update. TheSMC 2100, for runtime data, uses its platform object as thecommunications gateway to objects within the rest of the distributedsystem for purposes of sending and receiving diagnostic/remedialmessages. The SMC 2100, for runtime data does not rely on theconfiguration database 124 for any of its services. Instead the SMC 2100communicates directly with the various target objects (after theirmessage exchange handles have been provided in response to a namingresolution request).

For some diagnostic data the SMC 2100 utilizes direct interfacesprovided on the source software target to ensure that the diagnosticdata gathering does not adversely effect the runtime communicationsperformance. For example:

-   -   Log file diagnostic messages 2115 are accessed via a direct set        of interfaces exposed on the logger interface 2114 as the volume        of data would deteriorate the runtime performance if transferred        via the attribute subscription method;    -   Galaxy Database Management 2118 is accessed utilizing direct        interfaces package manager 2117.

The SMC 2100 incorporates security to ensure that allmonitoring/management operations are invoked by authorized users. If thesecurity permission for a menu item is not provided then the displayedmenu item is grayed out for the particular user. If a runtime operationis not permitted then the operation is terminated and a dialog box israised to indicate that the operation has been denied due to security.

The content of the views and the capabilities of a user to viewdiagnostic information and issue commands to (e.g., set attributeswithin) remotely deployed objects is determined in the SMC 2100 by anextensible set of job-specific snap-ins 2104. The set of job-specificsnap-ins 2104 supply data and interface control definitions to themanagement console shell 2102. The management console shell 2102 thenpresents the data and functions to users via a graphical user interface.Thus, the management console shell 2102 is customized/extended bymodifying the set of installed snap-ins 2104.

In an embodiment of the invention, the set of snap-ins 2104 areinstalled on the management console shell 2102 deployed on a computer. Asystem/application object monitor 2106 enables the management consoleshell 2102 to display to a user the objects installed on the system andtheir status. The information provided by the system/application objectmonitor 2106 concerns the status of the operating software of the system(e.g., application engines, platforms, application objects, etc.). Theobject monitor 2106 enables a user, via the management console shell2102 provided interfaces, to start/stop/re-start any platform or engine.The object monitor 2106 provides information to the management consoleshell 2102 enabling a user to view performance statistics of platformsand engines. The object monitor 2106 communicates with the distributedsupervisory process control and manufacturing information applicationobjects 2112 (e.g., platform objects, engine objects, etc.) via thepreviously described message exchange communication facilities 2110. Thefeatures provided by the object monitor 2106 go beyond those provided bya process monitor that displays the operational status of processvariables that indicate the status of a controlled manufacturing process(e.g., pressures, temperatures, flow, etc.). A diagnostics extensions2108 snap-in includes a communications system (e.g., message exchange)monitor/debugger. Other suitable diagnostics extensions are contemplatedto handle virtually any monitoring/management function conceivable for asupervisory process control and manufacturing information system. Suchextensions are readily implemented through the extensible interfacearchitecture of the management console shell 2102, which is, by way ofexample the MICROSOFT management console.

In an embodiment of the invention, the SMC 2100 under the customizationinfluence of one of the snap-ins 2104 exhibits behaviors similar toMICROSOFT's WINDOWS 2000 explorer. Turning to FIG. 22, the SMC 2100 whendriven by the object monitor 2106 snap-in, provides a view of thedeployed objects in the system. This view is similar to the deploymentview available within the IDE and discussed herein above with referenceto FIG. 17. The view layout, in accordance with the general MICROSOFTMANAGEMENT CONSOLE conventions and driven by object monitor 2106snap-in, exhibit the following view behaviors:

-   -   1) The left hand pane 2200 displays a tree view of the        deployment model.    -   2) The left hand pane 2200 uses the standard expand and collapse        tree indicators to expand or collapse the left hand tree.    -   3) The right hand pane 2202 indicates the status of a selected        object. This contains:        -   a) Object Name TagName and HierarchicalName        -   b) Object Template Name        -   c) Object Status—Started/Stopped/OnScan/OffScan    -   4) Both views automatically update to changed data (obtained via        message exchange)        -   a) The refresh frequency is configurable from a pull down            menu.        -   b) The default is 10 seconds and is configurable down to 1            Sec.    -   5) On start-up:        -   a) The left hand pane 2200 shows the name (e.g.,            MyApplication) of the system (also referred to as “Galaxy”)            within which the distributed application operates.        -   b) The right pane 2202 contains the platforms (e.g.,            Platform001 and Platform 002) defined within the global data            and the connection status (e.g., Running-OnScan).    -   6) By either clicking on the expand symbol for the galaxy name        or double clicking on the galaxy name in the left hand pane 2200        the tree expands to show the platforms within the left hand pane        2200. This method is available for all objects that have an        expansion symbol next to them.    -   7) By expanding a platform node, a tree of the engines is shown        on the left pane 2200 and the right pane 2202 will display the        engines' basic states.    -   8) Selecting an Engine in the left pane 2200 or by double        clicking in the right pane 2202 provides a view of all objects        that are hosted by the selected engine (e.g., area objects and        device integration objects).    -   9) Areas have an expansion symbol indicating that they host        ApplicationObjects. See,

FIG. 23, for an example of an expanded tree and attributes of a selectedapplication object V101 (T001.Inlet).

With reference to FIG. 22, in an embodiment of the invention a user iscapable of activating a context menu 2204 for each object displayed onthe user interface rendered by the SMC 2100. The context menu contains alist of the operations that can be submitted to the selected object. Thelist on dependent on the user's authenticated security and the objecttype. Functions that the user does not have permissions for will appeargrayed out on the context menu 2204. By way of example, the context menucontains: Start/Stop Platform/Engine—based on the object state;OnScan/OffScan—Based on the Object Status; and Add to Favorites—thatsaves the object to the favorites view for later viewing. A user maythus designate favorite views to reduce the time involved in traversingthe tree structure to reach a desired view of an object or set ofobjects.

Referring now to FIG. 23, the SMC 2100 provides a detailed grid forviewing object attributes of a selected application object V101(T001.Inlet). Such objects attribute displays include in general: Name,description and any exposed attributes. Particular types of objects andtheir exposed attributes include:

-   -   Galaxy—Database statistics    -   Platform—PC information such as OS version    -   Application Engine—Message Exchange and Scan statistics    -   View Engine—Display draw and Message statistics    -   Device Integration Network—Transaction rates & unconnected PLC's    -   Device Integration Device—Individual PLC transaction and error        statistics

With continued reference to FIG. 23, control buttons 2300 and 2302 aresupplied to launch sorting and filtering displayed properties in theright hand pane of the display. The user is therefore able to controlthe content of the displayed columns as well as its order ofpresentation. As shown in FIG. 23, the value property column of anattribute displays a reference string 2304 for the input/output ifapplicable. The reference string 2304 acts as a hyperlink so that theuser can trace through objects. The ←→ buttons act as in MICROSOFTExplorer browser traversing the latest user views.

Furthermore, in an embodiment of the invention the Value property willbe write-enabled (possibly via double click or a context action).Thereby not only allowing a user to diagnose a problem, but also takeremedial action by specifying a command on an attribute. A dialog isdisplayed suitable for the data type. The dialog allows a user (if theyhave the correct security permissions) to write to the attribute. Bydefault the write privilege will be in User mode, however the dialogwill provide the user with the capability to do both supervisory andsystems writes. Examples of management operations executable via suchwrite commands include: bringing objects onscan/offscan; start/stopengine, setting the alarm mode to enabled/disabled/silenced.

The SMC 2100 can be used as an effective administrative tool forperforming a number of high level system control operations. Thesefunctions are briefly discussed herein below. One high level taskfacilitated by the SMC is to perform a platform recovery for a previousbreakdown. An administrator selects the platform from the global datalist and requests initiates the recovery. In response, the full softwarere-deployment is carried out from the configuration database 124. If theplatform chosen is the local platform then a message is displayedindicating that the selected platform is the one the user is currentlylogged onto. If the option is to continue then the SMC will be stoppedand no indication is given of when the process has been completed.

Another administrative task is to purge all system log files. This taskis based on a date entered by the user. All logs will be deleted thathave a creation date prior to the supplied date. The user is presentedthe option to back up the files before deleting.

The Galaxy database manager 2116 from the SMC 2100 provides a mechanismfor the user to back-up/restore a single distributed application fromthe configuration database 124.

For Back-up they will be required to:

-   -   Enter the GalaxyRepository    -   Select the Galaxy within the GalaxyRepository    -   Enter target destination file name for the back-up log    -   Start the backup process.

The back-up once complete will contain all the configuration and filesrequired to recreate the application configuration into an emptyconfiguration database. The recovery process utilizes the selectedbackup file to overwrite or create a new application configurationwithin the configuration database 124. The restore process restores thewhole application configuration with the deployment state defined at thepoint that the application configuration was backed up

The SMC 2100 also supports a system software logging utility LogViewer2113 that enables all system objects and framework software to reportoperational errors, statistics, etc. that enable technical support orsystems engineers to diagnose and remedy software performance problems.The system software logger is the low level logger used by theinfrastructure and objects of the system depicted in FIG. 1 to reportinformation that is required by technical support or end user systemsengineers attempting to diagnose problems with the software. The systemsoftware logger is not the target location for application level logging(stored in the historian). The log maintained by the system softwarelogger is available at all times. In an embodiment of the invention thelog is stored in binary file format to ensure that the logging operationhas minimal impact on the runtime performance.

The retention policy for logs is configurable. Users can configure theretention period for all of the software log files. The configuredpolicy can be based, for example, upon a number of days or the amount ofdisk space dedicated to the log files. When the size of the disk spacetaken is changed form larger to smaller the log information truncatesthe oldest information. The file format of the log is abstracted fromthe clients so that as software technology advances the storage formatcan be changed without causing ripple effects through the rest of thearchitecture.

Table 1 below sets forth pre-defined log flags for the logger. All logflags are in the off state except for Error, Warning and Info.

TABLE 1 Error Log an error message. Error messages are used to indicatean error condition from which you cannot continue. This indicates asoftware problem that should not have occurred. Warning Log a warningmessage. Warning messages are used to indicate an error condition fromwhich you can continue, but the output may not be what was desired. InfoLog an informational message. Info messages simply describe successfulcompletion of large tasks, or other things that may be of casualinterest to the user. This should not be used for frequently loggingmessages. Trace Log a generic trace message. Used for detailed messagesabout the internal operations of a component. Start-Stop Log that somecomponent has started or stopped. These messages can help in showingwhen certain processes or objects have been started or shut down.ThreadStart-Stop Log that a thread has started or stopped. SQL Log SQLrelated messages. These messages can be used for tasks such as dumpingSQL select strings that are too long to be viewed in the DeveloperStudio debugger. RefCount Log object reference counts. This is usedmainly for COM object ref counts but can be used for any object thatmanages its life time by counting its clients. Entry-Exit Log a functionentry/exit message. These messages simply flag that functions have beenentered and exited. Connection Log a connection message. This is usedmainly by communication components that manage there connections withclients or servers. Ctor-Dtor Log a Constructor/Destructor message.

From an option within the SMC 2100, it will be possible to turn on oroff the information messages and debug messages for a specific object orset of objects. This will provide the developer the ability to providefull diagnostics, and turn these functions off at runtime to avoidflooding the logs and degrading the performance of the system.

In an embodiment of the invention, the software developer, for examplean ApplicationObject developer, can generate their own log categoriesand “register” them via the logger interface 2114. This provides thedeveloper a way to quickly isolate their specific log information viathe filtering mechanism mentioned herein below.

In an embodiment of the invention, the log file contains:

-   -   Software start-up    -   Software termination reports        -   Why the termination occurred (Planned/Failure)        -   Failure information if possible    -   Software information messages        -   Security login/logout        -   Security infractions        -   Connection requests from Internet clients    -   Debug messages        -   Software debug messages used to enable detailed diagnostics            of Magellan infrastructure.        -   Software debug state changes on→off and off→on

In an embodiment of the invention, the following fields will beavailable:

-   -   Platform Name—PC/platform name    -   Date/Time—File time    -   Component—IDE, SMC, Object Name    -   LogFlag Name—Debug, Information, Warning, Error . . .    -   Message—Description

Source is defined by the Object Model,

Message Identifier and Description are free format

In an embodiment of the invention, a logger viewer 2113 facilitatesproviding a view across all of the log files available on a localplatform. Furthermore, the logger viewer functionality is extended todesignated non-local platforms as well. The display provides a grid typeview onto the log messages. The display refreshes when the user isviewing the latest page of information. If the user has moved off thispage by using the [PageUP],[PageDown], [UpArrow],[DownArrow], [Home]Keys or using the Scroll bar then the page is not automaticallyrefreshed. The display also reacts to the scroll wheel available withmost new mice. The [End] key returns the user to the latest entry in thelog, and therefore restart automatic refresh. The refresh frequency isset dynamically to the refresh frequency of the local client. Therefresh frequency persists across restarts of the snap-in of the set ofsnap-ins 2104 that is responsible for the logging functionality of theSMC 2100.

In an embodiment of the invention it is possible to create a filter onany of the available fields within the log file. This filter will be asimple “and” filter, for example:

Source=AppEngine1 AND LogFlagName=Name AND Description=“Dead” The filteris provided by a fill in the gaps style form using where possibleselection controls for the well-known columns. Users select the starttime to view or all logs entries between two specified times.

Illustrative embodiments of the present invention and certain variationsthereof have been provided in the Figures and accompanying writtendescription. The present invention is not intended to be limited tothese embodiments. It will be appreciated by those skilled in the artthat a new and useful method and application has been described fordeploying software and a configuration for a process control andmanufacturing information application and thereafter monitoring thedeployed distributed application through a general management shellcustomized to support diagnostic/remedial operations via a set of snapin software modules. In view of the many possible environments to whichthe principles of this invention may be applied and the flexibility ofdesigning and carrying out software-based systems, it should berecognized that the embodiments described herein are meant to beillustrative and should not be taken as limiting the scope of theinvention. Those skilled in the art to which the present inventionapplies will appreciate that the illustrated embodiments can be modifiedin arrangement and detail without departing from the spirit of theinvention. The present invention is intended to cover the disclosedembodiments as well as others falling within the scope and spirit of theinvention to the fullest extent permitted in view of this disclosure andthe inventions defined by the claims appended herein below. Therefore,the invention as described herein contemplates all such embodiments asmay come within the scope of the following claims and equivalentsthereof.

1. A centralized diagnostics management tool facilitating monitoring ofdistributed components of a supervisory process control andmanufacturing information application, the centralized diagnosticsmanagement tool comprising: a diagnostics management console shellcomprising: a set of view templates, the view templates includingcontrols for manipulating graphically displayed representations of datarendered by the distributed components, and an interface customizationsoftware interface for integrating an extensible set of software modulesproviding data links to ones of the set of distributed components; and aset of software modules that submit requests to the distributedcomponents to access exposed attributes corresponding to operationalstatus of the components.
 2. The centralized diagnostics management toolof claim 1 wherein the set of software modules access diagnostic datarelating to the operational status of: platforms and applicationengines.
 3. The centralized diagnostics management tool of claim 2wherein the set of software modules access diagnostic data relating tothe operational status of a real time database.
 4. The centralizeddiagnostics management tool of claim 2 wherein the set of softwaremodules access diagnostic data relating to the operational status of adata access server.